home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 January / macformat-020.iso / Shareware City / Developers / PopupCDEF-10b4 / Source / PopupCDEF.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-01  |  9.3 KB  |  323 lines  |  [TEXT/KAHL]
  1. /* See the file Distribution for distribution terms.
  2.     (c) Copyright 1994 Ari Halberstadt */
  3.  
  4. /*    This file contains a popup CDEF that uses the file PopupLib.c to handle
  5.     the details of popup menus. This file contains glue to link the Control
  6.     Manager and the routines in PopupLib.c.
  7.  
  8.     94/07/06 aih
  9.     - Adapted for universal headers
  10.  
  11.     94/03/15 aih
  12.     - Added check against kPopupVersion before a CDEF is attached during
  13.     debugging with PopupCDEFAttach.
  14.     - Moved description to documentation file.
  15.     - Uses bullet instead of check mark as mark character when using
  16.     window font.
  17.     - Added support for the popupFixedWidth variation code.
  18.     
  19.     94/01/19 aih
  20.     - Added call to GetMHandle to allow use of menus created by the application
  21.     that are not in the resource file. Also fixed use of an already disposed
  22.     handle in the CDEF's dispose routine. Thanks to Eric Bowman (bobo@reed.edu)
  23.     for both of these.
  24.      
  25.     93/12/31 aih
  26.     - Returns 1 as part code (same as 7.0 CDEF) instead of inCheckBox
  27.     
  28.     93/12/26 aih
  29.     - Major overhaul. Now supports most of the features of the System 7.0 CDEF.
  30.     - Added functions for installing a glue handle to the popup CDEF,
  31.     allowing the CDEF to be debugged from within an application. The only
  32.     message that can't be debugged this way is the initCntl message.
  33.     
  34.     93/12/24 aih
  35.     - Adapted to use PopupHandle type
  36.     - Removed dependence on other libraries
  37.     - Simplified by removing complicated variation setting code
  38.     based on parsing the title string
  39.     
  40.     91/03/15 aih
  41.     - Fixed bug which caused a crash if the menu resource specified in the
  42.     control's refCon field couldn't be loaded
  43.     
  44.     91/03/04-05 Ari Halberstadt (aih)
  45.     - Created this file */
  46.     
  47. #include <limits.h>
  48. #include <Memory.h>
  49. #include <Resources.h>
  50. #include <SetUpA4.h>
  51. #include <TextEdit.h>
  52. #include <ToolUtils.h>
  53. #include "PopupLib.h"
  54. #include "PopupLM.h"
  55.  
  56. /* mask for the low 31 bits of the calcCRgns message to CDEFs */
  57. #define calcCRgnsMask        (0x7fffffffL)
  58.  
  59. /* hilite value for a disabled control */
  60. #define kControlDisabled    (255)
  61.  
  62. /* System software version needed to use this CDEF. Tested with system 6.0.5
  63.     and 7.0, but may work on systems as early as 4.0.1. */
  64. #define kSystemVersion        (0x0605)
  65.  
  66. /* The checkMark character is only present in the Chicago system font,
  67.     whereas the bullet character ('•') is present in most fonts. When the
  68.     popupUseWFont variation code is used, we change the mark character
  69.     from the default checkMark to kBulletMark. */
  70. #define kBulletMark            ('•')
  71.  
  72. /*    When debugging, it's convenient to have the CDEF ignore the
  73.     initCntl message, so that we can send it our own message
  74.     to initialize it when web call PopupCDEFAttach. */
  75. #ifndef NDEBUG
  76.     #define initCntlMsg        (1234)
  77. #else /* NDEBUG */
  78.     #define initCntlMsg        initCntl
  79. #endif /* NDEBUG */
  80.  
  81. /* draw the control */
  82. static void Draw(ControlHandle ctl, PopupHandle popup)
  83. {
  84.     Str255 title;
  85.     Rect bounds;
  86.     
  87.     GetCTitle(ctl, title);
  88.     bounds = (**ctl).contrlRect;
  89.     PopupDrawSet(popup, false);
  90.     PopupTitleSet(popup, title);
  91.     PopupBoundsSet(popup, &bounds);
  92.     PopupCurrentSet(popup, (**ctl).contrlValue);
  93.     PopupVisibleSet(popup, (**ctl).contrlVis != 0);
  94.     PopupEnableSet(popup, (**ctl).contrlHilite != kControlDisabled);
  95.     PopupDrawSet(popup, true);
  96.     PopupCalculate(popup);
  97.     PopupDraw(popup);
  98. }
  99.  
  100. /* return the part of the control that the point is in */
  101. static long Test(ControlHandle ctl, PopupHandle popup, Point where)
  102. {
  103.     return(PopupWithin(popup, where) ? kPopupPartCode : 0);
  104. }
  105.  
  106. /* calculate the region containing the control */
  107. static void Calculate(ControlHandle ctl, PopupHandle popup, RgnHandle rgn)
  108. {
  109.     Rect bounds;
  110.     
  111.     PopupBounds(popup, &bounds);
  112.     RectRgn(rgn, &bounds);
  113. }
  114.  
  115. /* load the menu and set 'gotmenu' to true if we called GetMenu */
  116. static MenuHandle LoadMenu(short id, Boolean *gotmenu)
  117. {
  118.     MenuHandle    menu;        /* the menu */
  119.     ProcPtr        errproc;    /* for saving and restoring ResErrProc */
  120.     short            load;        /* for saving and restoring ResLoad */
  121.     
  122.     /* we can tell if the menu hasn't been loaded by a call to GetMenu
  123.         since the menu handle will be a nil resource handle */
  124.     *gotmenu = false;
  125.     load = LMGetResLoad();
  126.     LMSetResLoad(false);
  127.     menu = (MenuHandle) GetResource('MENU', id);
  128.     LMSetResLoad(load);
  129.     if (menu && ! *menu) {
  130.         /* The menu is in the resource file, but it hasn't been loaded
  131.             yet, so we have to call GetMenu. */
  132.         errproc = LMGetResErrProc();
  133.         LMSetResErrProc(NULL);
  134.         menu = GetMenu(id);
  135.         LMSetResErrProc(errproc);
  136.         *gotmenu = true;
  137.     }
  138.     else if (! menu) {
  139.         /* To allow use of menus created by the application that are not in the
  140.             resource file we look for the menu in the menu list. */
  141.         menu = GetMHandle(id);
  142.     }
  143.     return(menu);
  144. }
  145.  
  146. /* initialize the control */
  147. static void Initialize(ControlHandle ctl, short var)
  148. {
  149.     MenuHandle    menu;        /* the menu */
  150.     PopupHandle popup;    /* handle to the popup menu */
  151.     Rect            bounds;    /* control's bounding rectangle */
  152.     short            nitems;    /* number of items in menu */
  153.     Boolean        gotmenu;    /* true if we created the menu by calling GetMenu */
  154.     
  155.     menu = LoadMenu((**ctl).contrlMin, &gotmenu);
  156.     if (menu) {
  157.         if (gotmenu && (var & popupUseAddResMenu) != 0)
  158.             AddResMenu(menu, (**ctl).contrlRfCon);
  159.         bounds = (**ctl).contrlRect;
  160.         popup = PopupBegin((**ctl).contrlOwner, menu, &bounds);
  161.         if (popup) {
  162.             (**popup).state.gotmenu = gotmenu;
  163.             PopupDrawSet(popup, false);
  164.             PopupTitleWidthSet(popup, (**ctl).contrlMax);
  165.             if (((**ctl).contrlValue & popupTitleNoStyle) == 0)
  166.                 PopupTitleStyleSet(popup, (**ctl).contrlValue >> CHAR_BIT);
  167.             if (((**ctl).contrlValue & popupTitleRightJust) == popupTitleRightJust)
  168.                 PopupJustSet(popup, teFlushRight);
  169.             if ((var & popupUseWFont) != 0)
  170.                 PopupMarkSet(popup, kBulletMark);
  171.             PopupTypeInSet(popup, (var & popupTypeIn) != 0);
  172.             PopupUseWFontSet(popup, (var & popupUseWFont) != 0);
  173.             PopupFixedWidthSet(popup, (var & popupFixedWidth) != 0);
  174.             PopupDrawSet(popup, true);
  175.             PopupCalculate(popup);
  176.             nitems = CountMItems(menu);
  177.             (**ctl).contrlMax = nitems;
  178.             (**ctl).contrlMin = (nitems > 0 ? 1 : 0);
  179.             (**ctl).contrlValue = (nitems > 0 ? 1 : 0);
  180.             (**ctl).contrlData = (Handle) popup;
  181.             #ifdef OLD_HEADERS
  182.                 (**ctl).contrlAction = (ProcPtr) -1L;
  183.             #else
  184.                 (**ctl).contrlAction = (ControlActionUPP) -1L;
  185.             #endif
  186.         }
  187.     }
  188. }
  189.  
  190. /* dispose of the control */
  191. static void Dispose(ControlHandle ctl, PopupHandle popup)
  192. {
  193.     MenuHandle menu;
  194.     Boolean gotmenu;
  195.     
  196.     menu = (**popup).menu;
  197.     gotmenu = (**popup).state.gotmenu;
  198.     PopupEnd(popup);
  199.     if (gotmenu)
  200.         ReleaseResource((Handle) menu);
  201.     (**ctl).contrlData = NULL;
  202. }
  203.  
  204. /* track a mouse click in the control */
  205. static void Track(ControlHandle ctl, PopupHandle popup)
  206. {
  207.     short value;
  208.     
  209.     PopupSelect(popup);
  210.     value = PopupCurrent(popup);
  211.     (**ctl).contrlValue = value;
  212. }
  213.  
  214. /* entry point for CDEF */
  215. pascal long PopupCDEF(short var, ControlHandle ctl, short msg, long param)
  216. {
  217.     PopupHandle    popup = NULL;
  218.     SysEnvRec world;
  219.     long result = 0;
  220.     
  221.     /* setup global variables */
  222.     RememberA0();
  223.     SetUpA4();
  224.     
  225.     /* check system software */
  226.     (void) SysEnvirons(curSysEnvVers, &world);
  227.     if (world.systemVersion >= kSystemVersion) {
  228.         
  229.         /* execute message */
  230.         popup = (PopupHandle) (**ctl).contrlData;
  231.         if (msg == initCntlMsg) {
  232.             Initialize(ctl, var);
  233.             popup = (PopupHandle) (**ctl).contrlData;
  234.         }
  235.         else if (popup) {
  236.             switch (msg) {
  237.             case drawCntl:
  238.                 param = LoWord(param); /* see TN196 */
  239.                 Draw(ctl, popup);
  240.                 break;
  241.             case testCntl:
  242.                 result = Test(ctl, popup, *(Point *) ¶m);
  243.                 break;
  244.             case calcCRgns:
  245.                 param &= calcCRgnsMask;
  246.                 /* no break */
  247.             case calcCntlRgn:
  248.             case calcThumbRgn:
  249.                 Calculate(ctl, popup, (RgnHandle) param);
  250.                 break;
  251.             case dispCntl:
  252.                 Dispose(ctl, popup);
  253.                 popup = NULL;
  254.                 break;
  255.             case autoTrack:
  256.                 param = LoWord(param); /* see TN196 */
  257.                 Track(ctl, popup);
  258.                 break;
  259.             }
  260.         }
  261.     }
  262.     RestoreA4();
  263.     return(result);
  264. }
  265.  
  266. #if CDEF
  267.  
  268. pascal long main(short var, ControlHandle ctl, short msg, long param)
  269. {
  270.     return(PopupCDEF(var, ctl, msg, param));
  271. }
  272.  
  273. #endif /* CDEF */
  274.  
  275. #if ! CDEF && ! NDEBUG
  276.  
  277. /* Functions for attaching a glue handle so the CDEF can be debugged
  278.     from within an application. */
  279.  
  280. /* the structure installed in the contrlDefProc field */
  281. typedef struct {
  282.     short jmp;                    /* jump instruction */
  283.     void *addr;                    /* address of CDEF function */
  284.     Handle contrlDefProc;    /* saved value of contrlDefProc field */
  285. } PopupGlueType, *PopupGluePtr, **PopupGlueHandle;
  286.  
  287. /* Set the control's defproc field to a small glue handle that will
  288.     jump to PopupCDEF. This makes debugging a lot easier, since you
  289.     can then step through the code with a debugger. */
  290. void PopupCDEFAttach(ControlHandle ctl)
  291. {
  292.     PopupGlueHandle glue;
  293.     
  294.     if (! (**ctl).contrlData ||
  295.          PopupVersion((PopupHandle) (**ctl).contrlData) == kPopupVersion)
  296.     {
  297.         glue = (PopupGlueHandle) NewHandleClear(sizeof(PopupGlueType));
  298.         if (glue) {
  299.             (**glue).jmp = ASM_M68K_JMP;
  300.             (**glue).addr = PopupCDEF;
  301.             (**glue).contrlDefProc = (**ctl).contrlDefProc;
  302.             (**ctl).contrlDefProc = (Handle) glue;
  303.             if (! (**ctl).contrlData)
  304.                 (void) PopupCDEF(GetCVariant(ctl), ctl, initCntlMsg, 0);
  305.         }
  306.     }
  307. }
  308.  
  309. /* Dispose of the glue handle created with PopupCDEFAttach and set the
  310.     control's contrlDefProc field to point to its original value. */
  311. void PopupCDEFDetach(ControlHandle ctl)
  312. {
  313.     PopupGlueHandle glue;
  314.     
  315.     if (PopupVersion((PopupHandle) (**ctl).contrlData) == kPopupVersion) {
  316.         glue = (PopupGlueHandle) (**ctl).contrlDefProc;
  317.         (**ctl).contrlDefProc = (**glue).contrlDefProc;
  318.         DisposeHandle((Handle) glue);
  319.     }
  320. }
  321.  
  322. #endif /* ! CDEF && ! NDEBUG */
  323.